デダクション・ガイド

可能であれば、concurrent_unordered_multimap コンストラクターは、クラス・テンプレート引数を推測することができます (C++17 以降)。コピーおよび移動コンストラクター (明示的な allocator_type 引数を持つコンストラクターを含む) は、暗黙的に生成されるデダクション・ガイドを提供します。さらに、次の明示的なデダクション・ガイドが提供されます。

template <typename InputIterator, 
          typename Hash = std::hash<iterator_key_t<InputIterator>>, 
          typename KeyEqual = std::equal_to<iterator_key_t<InputIterator>>, 
          typename Allocator = tbb::tbb_allocator<iterator_alloc_value_t<InputIterator>>> 
concurrent_unordered_multimap( InputIterator, InputIterator, 
                               map_size_type = {}, 
                               Hash = Hash(), 
                               KeyEqual = KeyEqual(), 
                               Allocator = Allocator() ) 
-> concurrent_unordered_multimap<iterator_key_t<InputIterator>, 
                                 iterator_mapped_t<InputIterator>, Hash, 
                                 KeyEqual, 
                                 Allocator>; 

template <typename InputIterator, 
          typename Hash, 
          typename Allocator> 
concurrent_unordered_multimap( InputIterator, InputIterator, 
                               map_size_type, 
                               Hash, 
                               Allocator ) 
-> concurrent_unordered_multimap<iterator_key_t<InputIterator>, 
                                 iterator_mapped_t<InputIterator>, 
                                 Hash, 
                                 std::equal_to<iterator_key_t<InputIterator>>, 
                                 Allocator>; 

template <typename InputIterator, 
          typename Allocator> 
concurrent_unordered_multimap( InputIterator, InputIterator, 
                               map_size_type, 
                               Allocator ) 
-> concurrent_unordered_multimap<iterator_key_t<InputIterator>, 
                                 iterator_mapped_t<InputIterator>, 
                                 std::hash<iterator_key_t<InputIterator>>, 
                                 std::equal_to<iterator_key_t<InputIterator>>, 
                                 Allocator>; 

template <typename Key, 
          typename T, 
          typename Hash = std::hash<std::remove_const_t<Key>>, 
          typename KeyEqual = std::equal_to<std::remove_const_t<Key>>, 
          typename Allocator = tbb::tbb_allocator<std::pair<const Key, T>>> 
concurrent_unordered_multimap( std::initializer_list<std::pair<Key, T>>, 
                               map_size_type = {}, 
                               Hash = Hash(), 
                               KeyEqual = KeyEqual(), 
                               Allocator = Allocator() ) 
-> concurrent_unordered_multimap<std::remove_const_t<Key>, 
                                 T, 
                                 Hash, 
                                 KeyEqual, 
                                 Allocator>; 

template <typename Key, 
          typename T, 
          typename Allocator> 
concurrent_unordered_multimap( std::initializer_list<std::pair<Key, T>>, 
                               map_size_type, 
                               Allocator ) 
-> concurrent_unordered_multimap<std::remove_const_t<Key>, 
                                 T, 
                                 std::hash<std::remove_const_t<Key>>, 
                                 std::equal_to<std::remove_const_t<Key>>, 
                                 Allocator>; 

template <typename Key, 
          typename T, 
          typename Allocator> 
concurrent_unordered_multimap( std::initializer_list<std::pair<Key, T>>, 
                               Allocator ) 
-> concurrent_unordered_multimap<std::remove_const_t<Key>, 
                                 T, 
                                 std::hash<std::remove_const_t<Key>>, 
                                 std::equal_to<std::remove_const_t<Key>>, 
                                 Allocator>; 

template <typename Key, 
          typename T, 
          typename Hash, 
          typename Allocator> 
concurrent_unordered_multimap( std::initializer_list<std::pair<Key, T>>, 
                               map_size_type, 
                               Hash, 
                               Allocator ) 
-> concurrent_unordered_multimap<std::remove_const_t<Key>, 
                                T, 
                                Hash, 
                                std::equal_to<std::remove_const_t<Key>>, 
                                Allocator>;

ここで、map_size_type タイプは、推測された concurrent_unordered_multimap の size_type メンバータイプを参照し、タイプエイリアス iterator_key_t、iterator_mapped_t、および iterator_alloc_value_t は次のように定義されます。

template <typename InputIterator> 
using iterator_key_t = std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>; 

template <typename InputIterator> 
using iterator_mapped_t = typename std::iterator_traits<InputIterator>::value_type::second_type; 

template <typename InputIterator> 
using iterator_alloc_value_t = std::pair<std::add_const_t<iterator_key_t<InputIterator>, 
                                         iterator_mapped_t<InputIterator>>>;

このデダクション・ガイドは、次の要件が満たされる場合にのみ、オーバーロードの解決に関係します。

  • InputIterator タイプは、[input.iterators] ISO C++ 標準の InputIterator の要件を満たしている必要があります。

  • Allocator タイプは、[allocator.requirements ISO C++ 標準の Allocator の要件を満たしている必要があります。

  • Hash タイプは Allocator の要件を満たしていません。

  • KeyEqual タイプは Allocator の要件を満たしていません。

例

#include <oneapi/tbb/concurrent_unordered_map.h> 
#include <vector> 
#include <functional> 

struct CustomHasher {...}; 

int main() { 
    std::vector<std::pair<int, float>> v; 

    // Deduces m1 as concurrent_unordered_multimap<int, float> 
    oneapi::tbb::concurrent_unordered_multimap m1(v.begin(), v.end()); 

    // Deduces m2 as concurrent_unordered_multimap<int, float, CustomHasher>; 
    oneapi::tbb::concurrent_unordered_multimap m2(v.begin(), v.end(), CustomHasher{}); 
}